package main

import (
	"fmt"
	"reflect"
)

/*
1.变量包含类型信息和值信息 类型是指针，变量是值类型
- 获取类型信息：reflect.TypeOf，是静态的
- 获取值信息：reflect.ValueOf，是动态的
*/
func main() {
	var x float64 = 3.4
	fmt.Println(x)
	reflect_type(x)
	fmt.Println("==reflectValue==")
	reflectValue(x)
	fmt.Println("==reflectSetValue==")
	// 反射认为下面是指针类型，不是float类型
	var y float64 = 3.4
	reflectSetValue(&y)
	fmt.Println("main:", y) // 7.9
}

// 反射获取interface类型信息
func reflect_type(a interface{}) {
	/*
		3.4
		type:  float64
		kind:  float64
	*/
	t := reflect.TypeOf(a)
	fmt.Println("type: ", t) // type:  float64
	// kind()可以获取具体类型
	k := t.Kind()
	fmt.Println("kind: ", k) // kind:  ptr
	switch k {
	case reflect.Int:
		fmt.Println("int")
	case reflect.String:
		fmt.Println("string")
	}
}

func reflectValue(x interface{}) {
	/*
		val: 3.4
		kind: float64
		float64
	*/
	v := reflect.ValueOf(x)
	fmt.Println("val:", v)
	k := reflect.TypeOf(x).Kind()
	fmt.Println("kind:", k)
	switch k {
	case reflect.Int:
		fmt.Println("int")
	case reflect.String:
		fmt.Println("string")
	case reflect.Float64:
		fmt.Println("float64")
	}
}

func reflectSetValue(a interface{}) {
	/*
		case: 7.9
		824633786576
		main: 7.9
	*/
	v := reflect.ValueOf(a)
	k := v.Kind()
	switch k {
	case reflect.Float64:
		// 反射修改值
		v.SetFloat(6.9)
		fmt.Println("a is ", v.Float())
	case reflect.Ptr:
		// Elem()获取地址指向的值
		v.Elem().SetFloat(7.9)
		fmt.Println("case:", v.Elem().Float())
		// 地址
		fmt.Println(v.Pointer())
	}
}
